home *** CD-ROM | disk | FTP | other *** search
/ Netware Super Library / Netware Super Library.iso / pgm_tool / lu62 / novell / int65.c < prev    next >
C/C++ Source or Header  |  1995-07-03  |  13KB  |  445 lines
  1. /*
  2.  * CopyRight 1995. Nicholas Poljakov all rights reserved.
  3.  */
  4. #include <dos.h>
  5. #include <string.h>
  6. #include <memory.h>
  7. #include <malloc.h>
  8. #include <stdio.h>
  9. #include <stdlib.h>
  10.  
  11. /* Stack and pointer checking off */
  12. #pragma check_stack( off )
  13. #pragma check_pointer( off )
  14. #pragma intrinsic( _enable, _disable )
  15.  
  16. /* Prototypes for interrupt function */
  17. void (_interrupt _far *oldint65)( void );
  18. void (_interrupt _far *oldint8)( void );
  19. void _interrupt _far rout( unsigned _es, unsigned _ds, unsigned _di,
  20.                    unsigned _si, unsigned _bp, unsigned _sp,
  21.                    unsigned _bx, unsigned _dx, unsigned _cx,
  22.                    unsigned _ax, unsigned _ip, unsigned _cs,
  23.                    unsigned _flags );
  24. void _interrupt _far int8( unsigned _es, unsigned _ds, unsigned _di,
  25.                    unsigned _si, unsigned _bp, unsigned _sp,
  26.                    unsigned _bx, unsigned _dx, unsigned _cx,
  27.                    unsigned _ax, unsigned _ip, unsigned _cs,
  28.                    unsigned _flags );
  29. void _interrupt _far DrEntry( unsigned _es, unsigned _ds, unsigned _di,
  30.                    unsigned _si, unsigned _bp, unsigned _sp,
  31.                    unsigned _bx, unsigned _dx, unsigned _cx,
  32.                    unsigned _ax, unsigned _ip, unsigned _cs,
  33.                    unsigned _flags );
  34. int fb(void *p);
  35. int SetRing(void);
  36. void *appl(void *);
  37. int rcv(void);
  38.  
  39. struct nau {
  40.      char name[8]    ;       /* nau name       */
  41.      unsigned char type ;    /* type           */
  42.      struct hscb *link;      /* hscb pointer   */
  43.      struct rqb *opnq;       /* opndst queue   */
  44.      short sid;              /* session id     */
  45.      unsigned char flag;     /* flag           */
  46.      unsigned char net_ad[6]; /* Novell network address     */
  47.      } naua[100];
  48.  
  49. void _far *nau_lst_ptr;
  50. void _far *hscb_lst_ptr;
  51. int totalNau = 1;
  52. int index;
  53.  
  54.  
  55. /* Huge pointers force compiler to do segment arithmetic for us. */
  56.  
  57. void _far  *InArea;
  58. void _far  *InAreaS;
  59. char _huge *tsrstack;
  60. char _huge *svstack;
  61. char _huge *Sstack = NULL;
  62. char _huge *Ssvstack;
  63. char _huge *tsvstack;
  64. char _huge *tsrbottom;
  65. int  code;
  66. int  Scode;
  67. int  length;
  68. int  Slength;
  69. int  total = 0;
  70. unsigned lock = 1;
  71.  
  72. speed = 1;
  73. width = 8;
  74. parity = 2;
  75. n_port = 2;
  76. stop_num = 1;
  77.  
  78. void *fe;
  79. void *le;
  80.  
  81. char _far *dosok;
  82.  
  83. unsigned ProgPrefix;
  84.  
  85. void main()
  86.         {
  87.             unsigned tsrsize;
  88.             unsigned char t;
  89.             unsigned dseg;
  90.             unsigned doff;
  91.             unsigned size;
  92.             unsigned seg;
  93.  
  94.  
  95.             /* Initialize stack and bottom of program. */
  96.             _asm {
  97.                   mov  ax, seg tsrstack
  98.                   mov  es, ax
  99.                   mov  WORD PTR es:tsrstack[0], sp
  100.                   mov  WORD PTR es:tsrstack[2], ss
  101.             }
  102.  
  103.             FP_SEG( tsrbottom ) = _psp;
  104.             FP_OFF( tsrbottom ) = 0;
  105.  
  106.             ProgPrefix = _psp;   /* Save PSP value */
  107.  
  108.             /* Program size is:
  109.              *     top of stack
  110.              *   - bottom of program (converted to paragraphs)
  111.              *   + one extra paragraph
  112.              */
  113.             tsrsize = ((tsrstack - tsrbottom) >> 4) + 1;
  114.  
  115.             _asm {
  116.                     mov  ah, 33h          ; check function
  117.                     int  6fh
  118.                     mov  byte ptr t[0], al    ; was int6f routine set ?
  119.             }
  120.             if (t != 0x55) {
  121.                 printf("I can't find IPX interface driver.\n");
  122.                 printf("IPX interface driver must be installed!\n");
  123.                 return ;
  124.             }
  125.  
  126.             if (SetRing() == -1) {
  127.                 printf("No core to install INT65.\n");
  128.                 return ;
  129.             }
  130.  
  131.  
  132.             /* Initialization NAU */
  133.             memset(&naua[0],0x00,100*sizeof(struct nau) );
  134.             hscb_lst_ptr = NULL;
  135.             nau_lst_ptr = &naua[0];
  136.  
  137.             _asm {
  138.                 mov   ax, 3400h
  139.                 int   21h
  140.                 mov   word ptr doff[0], bx
  141.                 mov   ax, es
  142.                 mov   word ptr dseg[0], ax
  143.             }
  144.  
  145.             FP_SEG( dosok ) = dseg;
  146.             FP_OFF( dosok ) = doff;
  147.  
  148.  
  149.             /*
  150.              * Allocate memory for second stack.
  151.              */
  152.             size = 1024; /* 1 K byte for second stack */
  153.             size >= 4;
  154.             if (_dos_allocmem(size, &seg)) {
  155.                 printf("Sorry. No memory for second Stack.\n");
  156.                 exit (0);
  157.             }
  158.             FP_SEG( Sstack ) = seg;
  159.             FP_OFF( Sstack ) = 0x400; /* SP points to end of stack */
  160.  
  161.             printf("Mini-Port now installed.\n");
  162.         /* Replace existing int65 & int8 routine with our. */
  163.             _asm cli
  164.             oldint8 = _dos_getvect( 0x8 );
  165.             _dos_setvect( 0x8, int8 );
  166.             oldint65 = _dos_getvect( 0x65 );
  167.             _dos_setvect( 0x65, rout );
  168.  
  169.             /* Free the PSP segment and terminate with program resident. */
  170.             _dos_keep( 0, tsrsize );
  171.         }
  172.  
  173. void _interrupt _far rout( unsigned _es, unsigned _ds, unsigned _di,
  174.                    unsigned _si, unsigned _bp, unsigned _sp,
  175.                    unsigned _bx, unsigned _dx, unsigned _cx,
  176.                    unsigned _ax, unsigned _ip, unsigned _cs,
  177.                                unsigned _flags )
  178. {
  179.  
  180.       FP_OFF( InArea ) = _dx;
  181.       FP_SEG( InArea ) = _ds;
  182.       code = _ax;
  183.       length = _cx;
  184.  
  185.       if (lock) {
  186.             lock = 0;
  187.             _asm {
  188.                      mov  ax, seg svstack
  189.                      mov  es, ax
  190.                      mov  WORD PTR es:svstack[0], sp
  191.                      mov  WORD PTR es:svstack[2], ss
  192.                      mov  ax, seg tsrstack
  193.                      mov  es, ax
  194.                      mov  sp, WORD PTR es:tsrstack[0]
  195.                      mov  ss, WORD PTR es:tsrstack[2]
  196.                  }
  197.             switch (code) {
  198.               case 0:  appl(InArea);
  199.                        break;
  200.               case 1:  if (!total) {
  201.                           rcv();
  202.                        }
  203.                        break;
  204.             }
  205.             _asm cli
  206.             _ax = 0;
  207.             lock = 1;
  208.             _asm {
  209.                      cli
  210.                      mov  ax, seg svstack
  211.                      mov  es, ax
  212.                      mov  sp, WORD PTR es:svstack[0]
  213.                      mov  ss, WORD PTR es:svstack[2]
  214.            }
  215.       }
  216.  }
  217.  
  218. void _interrupt _far DrEntry( unsigned _es, unsigned _ds, unsigned _di,
  219.                    unsigned _si, unsigned _bp, unsigned _sp,
  220.                    unsigned _bx, unsigned _dx, unsigned _cx,
  221.                    unsigned _ax, unsigned _ip, unsigned _cs,
  222.                                unsigned _flags )
  223. {
  224.  
  225.       _asm cli
  226.       FP_OFF( InAreaS ) = _dx;
  227.       FP_SEG( InAreaS ) = _ds;
  228.       Scode = _ax;
  229.       Slength = _cx;
  230.       _asm {
  231.                mov  ax, seg Ssvstack
  232.                mov  es, ax
  233.                mov  WORD PTR es:Ssvstack[0], sp
  234.                mov  WORD PTR es:Ssvstack[2], ss
  235.                mov  ax, seg Sstack
  236.                mov  es, ax
  237.                mov  sp, WORD PTR es:Sstack[0]
  238.                mov  ss, WORD PTR es:Sstack[2]
  239.       }
  240.       if (Scode == 0) {
  241.         if (*((char*)InAreaS+28) == 1 ) { /* attach LU */
  242.               totalNau++;
  243.               for(index = 1; index <= totalNau; index++){
  244.                   if( (naua[index].flag & 0x80) == 0){
  245.                       naua[index].flag |= 0x80;
  246.                       memcpy( &(naua[index].name),((char*)InAreaS+29),8);
  247.                       memcpy( &(naua[index].net_ad),InAreaS,6);
  248.                       if( index < totalNau)
  249.                             totalNau--;
  250.                       break;
  251.                   }
  252.               }
  253.         }
  254.         else
  255.                 if ((*((char*)InAreaS+28) == 2)&&(totalNau > 1)) { /* detach LU */
  256.                       for( index = 1; index <= totalNau; index++){
  257.                           if (memcmp( ((char*)InAreaS+29), naua[index].name,8) == 0){
  258.                   naua[index].flag &= 0x7f;
  259.                                   if ( index == totalNau )
  260.                                         totalNau-- ;
  261.                                   break;
  262.               }
  263.               }
  264.  
  265.                 }
  266.       }
  267.       else
  268.            fb(InAreaS);
  269.       _asm {
  270.                cli
  271.                mov  ax, seg Ssvstack
  272.                mov  es, ax
  273.                mov  sp, WORD PTR es:Ssvstack[0]
  274.                mov  ss, WORD PTR es:Ssvstack[2]
  275.       }
  276.  }
  277.  
  278. int fb(char *p)
  279. {
  280.         register int rest;
  281.         char *t;
  282.         struct ce {
  283.                      struct ce *next;
  284.                      unsigned desc;
  285.                      int lt;
  286.                      char b[120];
  287.                    } *re;
  288.  
  289.         re = le; /* last element */
  290.         t = p;
  291.     if ((rest = Slength) == 0) {
  292.         return 0;
  293.     }
  294.     while (rest) {
  295.             if (rest > 120) {
  296.                 memcpy(re -> b, p, 120);
  297.                 re -> desc = 1; /* middle segment */
  298.                 re -> lt = 120;
  299.                 p += 120;
  300.                 rest -= 120;
  301.                 re = re -> next;
  302.             }
  303.             else {
  304.                    memcpy(re -> b, p, rest);
  305.                    re -> desc = 0; /* end or single segment */
  306.                    re -> lt = rest;
  307.                    rest = 0;
  308.                  }
  309.         }
  310.         le = re -> next; /* Reset pointer to last element */
  311.         total = 1;
  312.         return 0;
  313. }
  314.  
  315. int rcv()
  316. {
  317.         struct ce {
  318.                      struct ce *next;
  319.                      unsigned desc;
  320.                      int lt;
  321.                      char b[120];
  322.                    } *re;
  323.         register int i;
  324.         register unsigned dsc;
  325.         char *p;
  326.         char *t;
  327.  
  328.  
  329.         re = fe; /* first element of the buffer ring */
  330.   Repete:
  331.         i = 0;
  332.         do {
  333.                 i += re -> lt;
  334.                 dsc = re -> desc;
  335.                 re = re -> next;
  336.         } while (dsc);
  337.  
  338.         if ((p = malloc(i)) == NULL) {
  339.             printf("No memory for make receive function.\n");
  340.             return 0;
  341.         }
  342.  
  343.         re = fe; /* first element of the buffer ring */
  344.         t = p;
  345.         do {
  346.                 memcpy(t, re -> b, re -> lt);
  347.                 t += re -> lt;
  348.                 dsc = re -> desc;
  349.                 re = re -> next;
  350.         } while (dsc);
  351.  
  352.         appl(p + 12);
  353.         free( p );
  354.         fe = re;
  355.  
  356.         if (le == fe) {
  357.                 total = 0;
  358.         }
  359.         else
  360.                 goto Repete;
  361.  
  362.         return 0;
  363. }
  364.  
  365. /*
  366.  * Set ring of the input buffers.
  367.  * Input buffers will be fills by receive exit
  368.  * subruotine.
  369.  */
  370.  
  371. int SetRing()
  372. {
  373.         /* Element of the buffer ring */
  374.  
  375.         struct ce {
  376.                      struct ce *next;
  377.                      unsigned desc;
  378.                      int lt;
  379.                      char b[120];
  380.                    } *re;
  381.  
  382.         struct ce *first;
  383.         struct ce *temp;
  384.         register int i;
  385.  
  386.     if ((temp = malloc(sizeof(struct ce))) == NULL) {
  387.             return -1;
  388.         }
  389.         first = temp;
  390.  
  391.         for (i = 0; i < 18; i++) {
  392.         if ((re = malloc(sizeof(struct ce))) == NULL) {
  393.         re = temp;
  394.         break;
  395.             }
  396.             else  {
  397.                      temp -> next = re;
  398.                      temp = re;
  399.                   }
  400.         }
  401.         re -> next = first;   /* Complete the ring */
  402.  
  403.         fe = first;  /* first element of the ring */
  404.         le = first;  /* last element of the ring */
  405.         return 0;
  406. }
  407.  
  408. void _interrupt _far int8( unsigned _es, unsigned _ds, unsigned _di,
  409.                    unsigned _si, unsigned _bp, unsigned _sp,
  410.                    unsigned _bx, unsigned _dx, unsigned _cx,
  411.                    unsigned _ax, unsigned _ip, unsigned _cs,
  412.                                unsigned _flags )
  413. {
  414.  
  415.        (*oldint8)();
  416.        _disable();
  417.         if ((total != 0) && (lock != 0)) {
  418.                 if (*dosok == 0) {
  419.                         _asm {
  420.                                  mov  ax, seg tsvstack
  421.                                  mov  es, ax
  422.                                  mov  WORD PTR es:tsvstack[0], sp
  423.                                  mov  WORD PTR es:tsvstack[2], ss
  424.                                  mov  ax, seg tsrstack
  425.                                  mov  es, ax
  426.                                  mov  sp, WORD PTR es:tsrstack[0]
  427.                                  mov  ss, WORD PTR es:tsrstack[2]
  428.                          }
  429.                         lock = 0;
  430.                         _asm sti
  431.                         rcv();
  432.                         _asm cli
  433.                         lock = 1;
  434.                         _disable();
  435.                         _asm {
  436.                                  mov  ax, seg tsvstack
  437.                                  mov  es, ax
  438.                                  mov  sp, WORD PTR es:tsvstack[0]
  439.                                  mov  ss, WORD PTR es:tsvstack[2]
  440.                                  mov  bp, sp
  441.                              }
  442.                 }
  443.     }
  444. }
  445.